//package com.scnu.hachimi.show;
//
//import com.scnu.hachimi.manager.MapLoader;
//import com.scnu.hachimi.manager.ResourcesManager;
//
//import javax.swing.*;
//import java.awt.*;
//import java.awt.event.*;
//import java.io.*;
//import java.nio.charset.StandardCharsets;
//import java.nio.file.*;
//import java.text.SimpleDateFormat;
//import java.util.*;
//import java.util.List;
//
//public class EditorJPanel extends JPanel {
//    private ResourcesManager rm;
//    private MainJFrame mjf;
//    private Image offScreenImage = null;
//
//    // 地图数据
//    private Map<String, List<Point>> mapData;
//    private String currentMapName = "";
//    private String selectedElement = "BRICK"; // 默认选择砖墙
//
//    // 元素类型列表
//    private final String[] elements = { "BRICK", "IRON", "GRASS", "RIVER", "base", "BOSS", "bot", "player1",
//            "player2" };
//    private int currentElementIndex = 0;
//
//    // UI组件
//    private JPanel controlPanel;
//    private JLabel mapNameLabel;
//    private JLabel lastModifiedLabel;
//
//    public EditorJPanel(ResourcesManager rm, MainJFrame mjf) {
//        this.rm = rm;
//        this.mjf = mjf;
//        this.mapData = new HashMap<>();
//
//        // 检查是否存在地图文件夹
//        File mapDir = new File("map");
//        if (!mapDir.exists()) {
//            mapDir.mkdir();
//        }
//
//        initializeUI();
//        setOpaque(false);
//        setupListeners();
//        revalidate(); // 重新布局所有子组件
//        repaint(); // 强制立即重绘
//    }
//
//    // 加载现有地图
//    public void loadMap(String mapName) {
//        try {
//            currentMapName = mapName;
//            mapData = MapLoader.getMap("map/" + mapName + ".map");
//            updateMapInfo();
//            repaint();
//        } catch (IOException e) {
//            JOptionPane.showMessageDialog(this, "加载地图失败：" + e.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
//        }
//    }
//
//    private void initializeUI() {
//        this.setLayout(new BorderLayout());
//        this.setPreferredSize(new Dimension(900, 660));
//
//        // 创建底部控制面板
//        controlPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 15));
//        controlPanel.setPreferredSize(new Dimension(900, 60));
//        controlPanel.setBackground(new Color(64, 64, 64));
//
//        // 创建统一的按钮样式
//        Font buttonFont = new Font("微软雅黑", Font.PLAIN, 14);
//        Dimension buttonSize = new Dimension(80, 30);
//        Color buttonColor = new Color(48, 48, 48);
//        Color buttonTextColor = Color.WHITE;
//
//        JButton backButton = createStyledButton("返回", buttonFont, buttonSize, buttonColor, buttonTextColor);
//        JButton loadButton = createStyledButton("加载", buttonFont, buttonSize, buttonColor, buttonTextColor);
//        JButton saveButton = createStyledButton("保存", buttonFont, buttonSize, buttonColor, buttonTextColor);
//        JButton deleteButton = createStyledButton("删除", buttonFont, buttonSize, buttonColor, buttonTextColor);
//
//        // 设置标签样式
//        Font labelFont = new Font("微软雅黑", Font.PLAIN, 12);
//        mapNameLabel = new JLabel("地图名称: 新地图");
//        mapNameLabel.setFont(labelFont);
//        mapNameLabel.setForeground(Color.WHITE);
//
//        lastModifiedLabel = new JLabel("最后修改: -");
//        lastModifiedLabel.setFont(labelFont);
//        lastModifiedLabel.setForeground(Color.WHITE);
//
//        // 添加组件到面板
//        controlPanel.add(backButton);
//        controlPanel.add(loadButton);
//        controlPanel.add(saveButton);
//        controlPanel.add(deleteButton);
//        controlPanel.add(mapNameLabel);
//        controlPanel.add(lastModifiedLabel);
//
//        this.add(controlPanel, BorderLayout.SOUTH);
//
//        // 按钮事件
//        backButton.addActionListener(e -> mjf.showIndex());
//        loadButton.addActionListener(e -> showLoadMapDialog());
//        saveButton.addActionListener(e -> saveMap());
//        deleteButton.addActionListener(e -> deleteMap());
//    }
//
//    private JButton createStyledButton(String text, Font font, Dimension size, Color bgColor, Color fgColor) {
//        JButton button = new JButton(text);
//        button.setFont(font);
//        button.setPreferredSize(size);
//        button.setBackground(bgColor);
//        button.setForeground(fgColor);
//        button.setFocusPainted(false);
//        button.setBorderPainted(false);
//        button.setOpaque(true);
//
//        // 添加鼠标悬停效果
//        button.addMouseListener(new MouseAdapter() {
//            @Override
//            public void mouseEntered(MouseEvent e) {
//                button.setBackground(new Color(80, 80, 80));
//            }
//
//            @Override
//            public void mouseExited(MouseEvent e) {
//                button.setBackground(bgColor);
//            }
//        });
//
//        return button;
//    }
//
//    private void showLoadMapDialog() {
//        File mapDir = new File("map");
//        File[] mapFiles = mapDir.listFiles((dir, name) -> name.endsWith(".map"));
//
//        if (mapFiles == null || mapFiles.length == 0) {
//            JOptionPane.showMessageDialog(this, "没有找到可用的地图文件");
//            return;
//        }
//
//        String[] mapNames = new String[mapFiles.length];
//        for (int i = 0; i < mapFiles.length; i++) {
//            mapNames[i] = mapFiles[i].getName().replace(".map", "");
//        }
//
//        String selected = (String) JOptionPane.showInputDialog(
//                this,
//                "选择要加载的地图：",
//                "加载地图",
//                JOptionPane.QUESTION_MESSAGE,
//                null,
//                mapNames,
//                mapNames[0]);
//
//        if (selected != null) {
//            loadMap(selected);
//        }
//    }
//
//    @Override
//    protected void paintComponent(Graphics g) {
//        super.paintComponent(g); // 让 Swing 正常绘制子组件（按钮、标签）
//
//        // 地图区域背景
//        g.setColor(Color.BLACK);
//        g.fillRect(0, 0, 800, 600);
//
//        // 网格
//        g.setColor(Color.DARK_GRAY);
//        for (int i = 0; i < 800; i += 20)
//            g.drawLine(i, 0, i, 600);
//        for (int i = 0; i < 600; i += 20)
//            g.drawLine(0, i, 800, i);
//
//        // 绘制地图元素
//        for (Map.Entry<String, List<Point>> entry : mapData.entrySet()) {
//            String type = entry.getKey();
//            for (Point p : entry.getValue()) {
//                Image img = rm.imageMap.get(type);
//                if (img != null) {
//                    boolean isLarge = type.equals("base") ||
//                            type.equals("BOSS") ||
//                            type.equals("bot") ||
//                            type.equals("player1") ||
//                            type.equals("player2");
//                    int w = isLarge ? 40 : 20;
//                    int h = w;
//                    g.drawImage(img, p.x, p.y, w, h, null);
//                }
//            }
//
//
//        }
//        // 右侧元素列表背景
//        g.setColor(Color.DARK_GRAY);
//        g.fillRect(800, 0, 100, 600);
//
//        // 元素列表标题
//        g.setColor(Color.WHITE);
//        g.setFont(new Font("微软雅黑", Font.BOLD, 14));
//        g.drawString("元素列表", 820, 30);
//
//        // 元素列表项
//        g.setFont(new Font("微软雅黑", Font.PLAIN, 12));
//        for (int i = 0; i < elements.length; i++) {
//            String ele = elements[i];
//            int y = 50 + i * 60;
//            Image img = rm.imageMap.get(ele);
//            if (img != null)
//                g.drawImage(img, 820, y, 40, 40, null);
//            g.setColor(Color.WHITE);
//            g.drawString(ele, 820, y + 55);
//            if (ele.equals(selectedElement)) {
//                g.setColor(Color.YELLOW);
//                g.drawRect(815, y - 5, 70, 60);
//            }
//        }
//    }
//
//    private void setupListeners() {
//        // 鼠标事件监听
//        addMouseListener(new MouseAdapter() {
//            @Override
//            public void mousePressed(MouseEvent e) {
//                int x = e.getX();
//                int y = e.getY();
//
//                // 网格对齐
//                x = (x / 20) * 20;
//                y = (y / 20) * 20;
//
//                // 检查是否点击了右侧元素列表
//                if (x >= 800 && x <= 900 && y < 600) {
//                    int elementIndex = (y - 50) / 60;
//                    if (elementIndex >= 0 && elementIndex < elements.length) {
//                        currentElementIndex = elementIndex;
//                        selectedElement = elements[currentElementIndex];
//                        repaint();
//                    }
//                    return;
//                }
//
//                int rx = x, ry = y;
//                if (selectedElement.equals("base") ||
//                        selectedElement.equals("bot") ||
//                        selectedElement.equals("player1") ||
//                        selectedElement.equals("player2") ||
//                        selectedElement.equals("BOSS")) {
//                    rx += 40;
//                    ry += 40;
//                }
//                else {
//                    rx += 20;
//                    ry += 20;
//                }
//                // 地图编辑区域限制
//                if (rx > 800 || ry > 600)
//                    return;
//
//
//                if (e.getButton() == MouseEvent.BUTTON1) { // 左键放置
//                    placeElement(x, y);
//                } else if (e.getButton() == MouseEvent.BUTTON3) { // 右键删除
//                    removeElement(x, y);
//                }
//                repaint();
//            }
//        });
//
//        // 鼠标滚轮切换元素
//        addMouseWheelListener(e -> {
//            if (e.getWheelRotation() > 0) { // 向下滚动
//                currentElementIndex = (currentElementIndex + 1) % elements.length;
//            } else { // 向上滚动
//                currentElementIndex = (currentElementIndex - 1 + elements.length) % elements.length;
//            }
//            selectedElement = elements[currentElementIndex];
//            repaint();
//        });
//    }
//
//    private void placeElement(int x, int y) {
//        // 检查是否已存在唯一元素
//        if (selectedElement.equals("player1") || selectedElement.equals("player2") ||
//                selectedElement.equals("base") || selectedElement.equals("BOSS")) {
//            removeExistingUniqueElement(selectedElement);
//        }
//        // 判断是否占 40×40
//        int blockW = (selectedElement.equals("base") || selectedElement.equals("BOSS") || selectedElement.equals("player1") || selectedElement.equals("player2") || selectedElement.equals("bot")) ? 40 : 20;
//        int blockH = blockW;
//
//        // 计算该元素将要占用的矩形
//        Rectangle newRect = new Rectangle(x, y, blockW, blockH);
//
//        // 遍历当前所有元素，检查是否重叠
//        for (Map.Entry<String, List<Point>> e : mapData.entrySet()) {
//            String t = e.getKey();
//            int existW = t.equals("base") || t.equals("bot") || t.equals("player1") || t.equals("player2") || t.equals("BOSS") ? 40 : 20;
//            int existH = existW;
//            for (Point pt : e.getValue()) {
//                Rectangle existRect = new Rectangle(pt.x, pt.y, existW, existH);
//                if (newRect.intersects(existRect)) {
//                    // 与 base 区域重叠
//                    if (t.equals("base") || selectedElement.equals("base")) {
//                        return; // 直接忽略放置
//                    }
//                }
//            }
//        }
//        // 添加新元素
//        mapData.computeIfAbsent(selectedElement, k -> new ArrayList<>())
//                .add(new Point(x, y));
//    }
//
//    private void removeElement(int x, int y) {
//        // 先尝试按 40×40 删除 base
//        Iterator<Map.Entry<String, List<Point>>> it = mapData.entrySet().iterator();
//        while (it.hasNext()) {
//            Map.Entry<String, List<Point>> e = it.next();
//            if ("base".equals(e.getKey()) || "bot".equals(e.getKey()) || "player1".equals(e.getKey()) || "player2".equals(e.getKey()) || "BOSS".equals(e.getKey())) {
//                Iterator<Point> pit = e.getValue().iterator();
//                while (pit.hasNext()) {
//                    Point pt = pit.next();
//                    if (x >= pt.x && x < pt.x + 40 &&
//                            y >= pt.y && y < pt.y + 40) {
//                        pit.remove(); // 删除整个 base
//                        return;
//                    }
//                }
//            }
//        }
//
//        // 再按 20×20 删除普通方块
//        for (List<Point> pts : mapData.values()) {
//            pts.removeIf(p -> p.x == x && p.y == y);
//        }
//    }
//
//    private void removeExistingUniqueElement(String elementType) {
//        List<Point> points = mapData.get(elementType);
//        if (points != null) {
//            points.clear();
//        }
//    }
//
//    private void saveMap() {
//        if (currentMapName.isEmpty()) {
//            // 生成新地图名称
//            File mapDir = new File("map");
//            int maxNum = 0;
//            for (File file : mapDir.listFiles()) {
//                if (file.getName().endsWith(".map")) {
//                    try {
//                        int num = Integer.parseInt(file.getName().replace(".map", ""));
//                        maxNum = Math.max(maxNum, num);
//                    } catch (NumberFormatException ignored) {
//                    }
//                }
//            }
//            currentMapName = String.valueOf(maxNum + 1);
//        }
//
//        String filePath = "map/" + currentMapName + ".map";
//        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, StandardCharsets.UTF_8))) {
//            for (Map.Entry<String, List<Point>> entry : mapData.entrySet()) {
//                if (!entry.getValue().isEmpty()) {
//                    StringBuilder line = new StringBuilder(entry.getKey()).append("=");
//                    for (Point p : entry.getValue()) {
//                        line.append(p.x).append(",").append(p.y).append(";");
//                    }
//                    line.setLength(line.length() - 1); // 移除最后的分号
//                    writer.write(line.toString());
//                    writer.newLine();
//                }
//            }
//            updateMapInfo();
//            JOptionPane.showMessageDialog(this, "地图保存成功！");
//        } catch (IOException e) {
//            JOptionPane.showMessageDialog(this, "保存失败：" + e.getMessage(), "错误", JOptionPane.ERROR_MESSAGE);
//        }
//    }
//
//    private void deleteMap() {
//        if (currentMapName.isEmpty()) {
//            JOptionPane.showMessageDialog(this, "请先保存地图！");
//            return;
//        }
//
//        int confirm = JOptionPane.showConfirmDialog(this,
//                "确定要删除地图 " + currentMapName + " 吗？",
//                "确认删除",
//                JOptionPane.YES_NO_OPTION);
//
//        if (confirm == JOptionPane.YES_OPTION) {
//            File mapFile = new File("map/" + currentMapName + ".map");
//            if (mapFile.delete()) {
//                JOptionPane.showMessageDialog(this, "地图删除成功！");
//                mjf.showIndex();
//            } else {
//                JOptionPane.showMessageDialog(this, "删除失败！", "错误", JOptionPane.ERROR_MESSAGE);
//            }
//        }
//    }
//
//    private void updateMapInfo() {
//        if (!currentMapName.isEmpty()) {
//            File mapFile = new File("map/" + currentMapName + ".map");
//            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
//            String lastModified = sdf.format(new Date(mapFile.lastModified()));
//
//            mapNameLabel.setText("地图名称: " + currentMapName);
//            lastModifiedLabel.setText("最后修改: " + lastModified);
//        }
//    }
//}

package com.scnu.hachimi.show;

import com.scnu.hachimi.manager.MapLoader;
import com.scnu.hachimi.manager.ResourcesManager;

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.List;

public class EditorJPanel extends JPanel {
    private ResourcesManager rm;
    private MainJFrame mjf;

    // 地图数据
    private Map<String, List<Point>> mapData;
    private String currentMapName = "";
    private String selectedElement = "BRICK"; // 默认选择砖墙

    // 元素类型列表
    private final String[] elements = { "BRICK", "IRON", "GRASS", "RIVER", "base", "BOSS", "elite", "player1", "player2" };
    private int currentElementIndex = 0;

    // 常量定义
    private static final int GRID_SIZE = 20;
    private static final int LARGE_ELEMENT_SIZE = 40;
    private static final int PANEL_WIDTH = 900;
    private static final int PANEL_HEIGHT = 660;
    private static final int MAP_WIDTH = 800;
    private static final int MAP_HEIGHT = 600;
    private static final int ELEMENT_LIST_WIDTH = 100;
    private static final Color CONTROL_PANEL_BG = new Color(64, 64, 64);
    private static final Color BUTTON_BG = new Color(48, 48, 48);

    // UI组件
    private JPanel controlPanel;
    private JLabel mapNameLabel;
    private JLabel lastModifiedLabel;

    public EditorJPanel(ResourcesManager rm, MainJFrame mjf) {
        this.rm = rm;
        this.mjf = mjf;
        this.mapData = new HashMap<>();

        // 检查并创建地图文件夹
        ensureMapDirectoryExists();

        initializeUI();
        setOpaque(false);
        setupListeners();
        revalidate();
        repaint();

        //初始化mapData
        for (String element : elements) {
            mapData.put(element, new ArrayList<>());
        }
    }

    // 确保地图目录存在
    private void ensureMapDirectoryExists() {
        File mapDir = new File("map");
        if (!mapDir.exists()) {
            mapDir.mkdir();
        }
    }

    // 加载现有地图
    public void loadMap(String mapName) {
        try {
            currentMapName = mapName;

            Map<String, List<Point>> loadedMap = MapLoader.getMap("map/" + mapName + ".map");

            // 保留现有键结构，只更新值
            for (String element : elements) {
                // 如果加载的地图包含此元素，则更新列表
                if (loadedMap.containsKey(element)) {
                    mapData.put(element, loadedMap.get(element));
                } else {
                    // 否则保留现有的空列表
                    mapData.put(element, new ArrayList<>());
                }
            }

            updateMapInfo();
            repaint();
        } catch (IOException e) {
            showErrorDialog("加载地图失败：" + e.getMessage());
        }
    }

    // 初始化UI组件
    private void initializeUI() {
        this.setLayout(new BorderLayout());
        this.setPreferredSize(new Dimension(PANEL_WIDTH, PANEL_HEIGHT));

        // 创建底部控制面板
        controlPanel = new JPanel(new FlowLayout(FlowLayout.CENTER, 20, 15));
        controlPanel.setPreferredSize(new Dimension(PANEL_WIDTH, 60));
        controlPanel.setBackground(CONTROL_PANEL_BG);

        // 创建按钮
        Font buttonFont = new Font("微软雅黑", Font.PLAIN, 14);
        Dimension buttonSize = new Dimension(80, 30);
        Color buttonTextColor = Color.WHITE;

        JButton backButton = createStyledButton("返回", buttonFont, buttonSize, BUTTON_BG, buttonTextColor);
        JButton loadButton = createStyledButton("加载", buttonFont, buttonSize, BUTTON_BG, buttonTextColor);
        JButton saveButton = createStyledButton("保存", buttonFont, buttonSize, BUTTON_BG, buttonTextColor);
        JButton renameButton = createStyledButton("重命名", buttonFont, buttonSize, BUTTON_BG, buttonTextColor);
        JButton deleteButton = createStyledButton("删除", buttonFont, buttonSize, BUTTON_BG, buttonTextColor);

        // 设置标签样式
        Font labelFont = new Font("微软雅黑", Font.PLAIN, 12);
        mapNameLabel = new JLabel("地图名称: 新地图");
        mapNameLabel.setFont(labelFont);
        mapNameLabel.setForeground(Color.WHITE);

        lastModifiedLabel = new JLabel("最后修改: -");
        lastModifiedLabel.setFont(labelFont);
        lastModifiedLabel.setForeground(Color.WHITE);

        // 添加组件到面板
        controlPanel.add(backButton);
        controlPanel.add(loadButton);
        controlPanel.add(saveButton);
        controlPanel.add(renameButton);
        controlPanel.add(deleteButton);
        controlPanel.add(mapNameLabel);
        controlPanel.add(lastModifiedLabel);

        this.add(controlPanel, BorderLayout.SOUTH);

        // 按钮事件
        backButton.addActionListener(e -> mjf.showIndex());
        loadButton.addActionListener(e -> showLoadMapDialog());
        saveButton.addActionListener(e -> saveMap());
        renameButton.addActionListener(e -> renameMap());
        deleteButton.addActionListener(e -> deleteMap());
    }

    // 创建带样式的按钮
    private JButton createStyledButton(String text, Font font, Dimension size, Color bgColor, Color fgColor) {
        JButton button = new JButton(text);
        button.setFont(font);
        button.setPreferredSize(size);
        button.setBackground(bgColor);
        button.setForeground(fgColor);
        button.setFocusPainted(false);
        button.setBorderPainted(false);
        button.setOpaque(true);

        // 添加鼠标悬停效果
        button.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseEntered(MouseEvent e) {
                button.setBackground(new Color(80, 80, 80));
            }

            @Override
            public void mouseExited(MouseEvent e) {
                button.setBackground(bgColor);
            }
        });

        return button;
    }

    // 显示加载地图对话框
    private void showLoadMapDialog() {
        File mapDir = new File("map");
        File[] mapFiles = mapDir.listFiles((dir, name) -> name.endsWith(".map"));

        if (mapFiles == null || mapFiles.length == 0) {
            showInfoDialog("没有找到可用的地图文件");
            return;
        }

        String[] mapNames = Arrays.stream(mapFiles)
                .map(f -> f.getName().replace(".map", ""))
                .toArray(String[]::new);

        String selected = (String) JOptionPane.showInputDialog(
                this,
                "选择要加载的地图：",
                "加载地图",
                JOptionPane.QUESTION_MESSAGE,
                null,
                mapNames,
                mapNames[0]);

        if (selected != null) {
            loadMap(selected);
        }
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        // 绘制地图区域背景
        drawMapBackground(g);

        // 绘制网格
        drawGrid(g);

        // 绘制地图元素
        drawMapElements(g);

        // 绘制右侧元素列表
        drawElementList(g);
    }

    // 绘制地图背景
    private void drawMapBackground(Graphics g) {
        g.setColor(Color.BLACK);
        g.fillRect(0, 0, MAP_WIDTH, MAP_HEIGHT);
    }

    // 绘制网格线
    private void drawGrid(Graphics g) {
        g.setColor(Color.DARK_GRAY);
        for (int i = 0; i < MAP_WIDTH; i += GRID_SIZE) {
            g.drawLine(i, 0, i, MAP_HEIGHT);
        }
        for (int i = 0; i < MAP_HEIGHT; i += GRID_SIZE) {
            g.drawLine(0, i, MAP_WIDTH, i);
        }
    }

    // 绘制地图元素
    private void drawMapElements(Graphics g) {
        for (Map.Entry<String, List<Point>> entry : mapData.entrySet()) {
            String type = entry.getKey();
            Image img = rm.imageMap.get(type);
            if (img == null) continue;

            boolean isLarge = isLargeElement(type);
            int size = isLarge ? LARGE_ELEMENT_SIZE : GRID_SIZE;

            for (Point p : entry.getValue()) {
                g.drawImage(img, p.x, p.y, size, size, null);
            }
        }
    }

    // 绘制右侧元素列表
    private void drawElementList(Graphics g) {
        // 背景
        g.setColor(Color.DARK_GRAY);
        g.fillRect(MAP_WIDTH, 0, ELEMENT_LIST_WIDTH, MAP_HEIGHT);

        // 标题
        g.setColor(Color.WHITE);
        g.setFont(new Font("微软雅黑", Font.BOLD, 14));
        g.drawString("元素列表", MAP_WIDTH + 20, 30);

        // 元素项
        g.setFont(new Font("微软雅黑", Font.PLAIN, 12));
        for (int i = 0; i < elements.length; i++) {
            String ele = elements[i];
            int y = 50 + i * 60;
            Image img = rm.imageMap.get(ele);

            if (img != null) {
                int size = isLargeElement(ele) ? LARGE_ELEMENT_SIZE : GRID_SIZE;
                g.drawImage(img, MAP_WIDTH + 20, y, size, size, null);
            }

            g.setColor(Color.WHITE);
            g.drawString(ele, MAP_WIDTH + 20, y + 55);

            // 绘制选中框
            if (ele.equals(selectedElement)) {
                g.setColor(Color.YELLOW);
                g.drawRect(MAP_WIDTH + 15, y - 5, 70, 60);
            }
        }
    }

    // 设置事件监听器
    private void setupListeners() {
        addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                handleMousePress(e);
            }
        });

        // 鼠标滚轮切换元素
        addMouseWheelListener(e -> {
            int rotation = e.getWheelRotation();
            currentElementIndex = (currentElementIndex + (rotation > 0 ? 1 : -1) + elements.length) % elements.length;
            selectedElement = elements[currentElementIndex];
            repaint();
        });
    }

    // 处理鼠标点击事件
    private void handleMousePress(MouseEvent e) {
        int x = e.getX();
        int y = e.getY();

        // 网格对齐
        x = (x / GRID_SIZE) * GRID_SIZE;
        y = (y / GRID_SIZE) * GRID_SIZE;

        // 检查是否点击了元素列表
        if (x >= MAP_WIDTH && x < PANEL_WIDTH && y < MAP_HEIGHT) {
            handleElementListClick(y);
            return;
        }

        // 检查是否在地图编辑区域内
        if (x >= MAP_WIDTH || y >= MAP_HEIGHT) return;

        if (e.getButton() == MouseEvent.BUTTON1) {
            placeElement(x, y);
        } else if (e.getButton() == MouseEvent.BUTTON3) {
            removeElement(x, y);
        }
        repaint();
    }

    // 处理元素列表点击
    private void handleElementListClick(int y) {
        int elementIndex = (y - 50) / 60;
        if (elementIndex >= 0 && elementIndex < elements.length) {
            currentElementIndex = elementIndex;
            selectedElement = elements[currentElementIndex];
            repaint();
        }
    }

    // 放置元素
    private void placeElement(int x, int y) {
        // 检查边界 - 确保元素不会超出地图边界
        if (isOutOfBounds(x, y, selectedElement)) {
            return;
        }

        // 检查是否是唯一元素（基地、BOSS、玩家）
        if (isUniqueElement(selectedElement)) {
            removeExistingUniqueElement(selectedElement);
        }

        // 检查放置区域是否重叠
        if (isOverlapping(x, y, selectedElement)) {
            return;
        }

        // 添加新元素
        mapData.computeIfAbsent(selectedElement, k -> new ArrayList<>())
                .add(new Point(x, y));
    }

    // 检查元素是否超出边界
    private boolean isOutOfBounds(int x, int y, String elementType) {
        int elementSize = isLargeElement(elementType) ? LARGE_ELEMENT_SIZE : GRID_SIZE;

        // 检查右下角是否超出边界
        if (x + elementSize > MAP_WIDTH || y + elementSize > MAP_HEIGHT) {
            return true;
        }
        return false;
    }

    // 移除元素
    private void removeElement(int x, int y) {
        // 先尝试移除大尺寸元素（40×40）
        for (String type : elements) {
            if (!isLargeElement(type)) continue;

            List<Point> points = mapData.get(type);
            if (points == null) continue;

            Iterator<Point> it = points.iterator();
            while (it.hasNext()) {
                Point p = it.next();
                if (x >= p.x && x < p.x + LARGE_ELEMENT_SIZE &&
                        y >= p.y && y < p.y + LARGE_ELEMENT_SIZE) {
                    it.remove();
                    return;
                }
            }
        }

        // 再移除小尺寸元素（20×20）
        for (List<Point> points : mapData.values()) {
            points.removeIf(p -> x >= p.x && x < p.x + GRID_SIZE &&
                    y >= p.y && y < p.y + GRID_SIZE);
        }
    }

    // 检查是否重叠
    private boolean isOverlapping(int x, int y, String elementType) {
        Rectangle newRect = getElementRect(elementType, x, y);

        // 检查与所有现有元素的碰撞
        for (Map.Entry<String, List<Point>> entry : mapData.entrySet()) {
            String existingType = entry.getKey();
            for (Point p : entry.getValue()) {
                Rectangle existingRect = getElementRect(existingType, p.x, p.y);
                if (newRect.intersects(existingRect)) {
                    return true;
                }
            }
        }
        return false;
    }

    // 获取元素矩形区域
    private Rectangle getElementRect(String elementType, int x, int y) {
        int size = isLargeElement(elementType) ? LARGE_ELEMENT_SIZE : GRID_SIZE;
        return new Rectangle(x, y, size, size);
    }

    // 判断元素是否为大尺寸（40×40）
    private boolean isLargeElement(String elementType) {
        return elementType.equals("base") ||
                elementType.equals("BOSS") ||
                elementType.equals("elite") ||
                elementType.equals("player1") ||
                elementType.equals("player2");
    }

    // 判断是否是唯一元素（基地、BOSS、玩家）
    private boolean isUniqueElement(String elementType) {
        return elementType.equals("base") ||
                elementType.equals("BOSS") ||
                elementType.equals("player1") ||
                elementType.equals("player2");
    }

    // 移除现有的唯一元素
    private void removeExistingUniqueElement(String elementType) {
        List<Point> points = mapData.get(elementType);
        if (points != null) {
            points.clear();
        }
    }

    // 保存地图
    private void saveMap() {
        // 如果没有地图名称，则生成一个
        if (currentMapName.isEmpty()) {
            currentMapName = generateNewMapName();
        }

        saveMapToFile(currentMapName);
    }

    // 重命名地图
    private void renameMap() {
        String newName = JOptionPane.showInputDialog(
                this,
                "输入新地图名称:",
                currentMapName.isEmpty() ? "重命名地图" : "重命名 " + currentMapName,
                JOptionPane.QUESTION_MESSAGE
        );

        if (newName == null) {
            return; // 用户取消了
        }

        // 如果名称为空，则生成UUID
        if (newName.trim().isEmpty()) {
            newName = generateShortUUID();
        }

        // 如果名称没有变化，直接返回
        if (newName.equals(currentMapName)) {
            return;
        }

        // 删除旧地图文件（如果存在）
        if (!currentMapName.isEmpty()) {
            File oldFile = new File("map/" + currentMapName + ".map");
            if (oldFile.exists()) {
                oldFile.delete();
            }
        }

        // 保存新地图文件
        saveMapToFile(newName);
        currentMapName = newName;
        updateMapInfo();
    }

    // 保存地图到文件
    private void saveMapToFile(String mapName) {
        String filePath = "map/" + mapName + ".map";
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(filePath, StandardCharsets.UTF_8))) {
            for (Map.Entry<String, List<Point>> entry : mapData.entrySet()) {
                if (entry.getValue().isEmpty()) continue;

                StringBuilder sb = new StringBuilder(entry.getKey()).append("=");
                for (Point p : entry.getValue()) {
                    sb.append(p.x).append(",").append(p.y).append(";");
                }
                sb.setLength(sb.length() - 1); // 移除最后的分号
                writer.write(sb.toString());
                writer.newLine();
            }

            //如果没有放置玩家或者敌人则提示
            if(mapData.get("player1").isEmpty() && mapData.get("player2").isEmpty() || mapData.get("elite").isEmpty() && mapData.get("BOSS").isEmpty()) {
                showErrorDialog("请放置玩家和敌人！");
                return;
            }

            updateMapInfo();
            showInfoDialog("地图保存成功！");
        } catch (IOException e) {
            showErrorDialog("保存失败：" + e.getMessage());
        }
    }

    // 生成新地图名称（使用UUID前6位）
    private String generateShortUUID() {
        return UUID.randomUUID().toString().substring(0, 6);
    }

    // 生成新地图名称（数字递增）
    private String generateNewMapName() {
        File mapDir = new File("map");
        int maxNum = 0;

        for (File file : mapDir.listFiles()) {
            if (file.getName().endsWith(".map")) {
                try {
                    String name = file.getName().replace(".map", "");
                    int num = Integer.parseInt(name);
                    maxNum = Math.max(maxNum, num);
                } catch (NumberFormatException ignored) {
                }
            }
        }
        return String.valueOf(maxNum + 1);
    }

    // 删除地图
    private void deleteMap() {
        if (currentMapName.isEmpty()) {
            showInfoDialog("请先保存地图！");
            return;
        }

        int confirm = JOptionPane.showConfirmDialog(
                this,
                "确定要删除地图 " + currentMapName + " 吗？",
                "确认删除",
                JOptionPane.YES_NO_OPTION
        );

        if (confirm == JOptionPane.YES_OPTION) {
            File mapFile = new File("map/" + currentMapName + ".map");
            if (mapFile.delete()) {
                showInfoDialog("地图删除成功！");
                mjf.showIndex();
            } else {
                showErrorDialog("删除失败！");
            }
        }
    }

    // 更新地图信息
    private void updateMapInfo() {
        if (!currentMapName.isEmpty()) {
            File mapFile = new File("map/" + currentMapName + ".map");
            if (mapFile.exists()) {
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                String lastModified = sdf.format(new Date(mapFile.lastModified()));
                lastModifiedLabel.setText("最后修改: " + lastModified);
            } else {
                lastModifiedLabel.setText("最后修改: -");
            }
            mapNameLabel.setText("地图名称: " + currentMapName);
        } else {
            mapNameLabel.setText("地图名称: 新地图");
            lastModifiedLabel.setText("最后修改: -");
        }
    }

    // 显示信息对话框
    private void showInfoDialog(String message) {
        JOptionPane.showMessageDialog(this, message);
    }

    // 显示错误对话框
    private void showErrorDialog(String message) {
        JOptionPane.showMessageDialog(this, message, "错误", JOptionPane.ERROR_MESSAGE);
    }
}